package com.yconme.callphone.Utils;

import android.app.Activity;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.provider.MediaStore;
import android.util.Log;

import com.yconme.callphone.Beasic.MyApp;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;


/** 
 * 文件工具类 
 */  
public class FileUtil {  
  
    private static final String TAG = "FileUtil";  
    private static String pathDiv = "/";  
    private static File cacheDir = !isExternalStorageWritable()? MyApp.applicationContext.getFilesDir():MyApp.applicationContext.getExternalCacheDir();;
  
    private FileUtil() {  
        /* cannot be instantiated */  
        throw new UnsupportedOperationException("cannot be instantiated");  
    }  
  
  
    /** 
     * 创建临时文件 
     * 
     * @param type 文件类型 
     */  
    public static File getTempFile(FileType type){  
        try{  
            File file = File.createTempFile(type.toString(), null, cacheDir);  
            file.deleteOnExit();  
            return file;  
        }catch (IOException e){  
            return null;  
        }  
    }  
  
  
    /** 
     * 获取缓存文件地址 
     */  
    public static String getCacheFilePath(String fileName){  
        return cacheDir.getAbsolutePath()+pathDiv+fileName;  
    }  
  
  
    /** 
     * 判断缓存文件是否存在 
     */  
    public static boolean isCacheFileExist(String fileName){  
        File file = new File(getCacheFilePath(fileName));  
        return file.exists();  
    }  
  
  
    /** 
     * 将图片存储为文件 
     * 
     * @param bitmap 图片 
     */  
    public static String createFile(Bitmap bitmap, String filename){  
        File f = new File(cacheDir, filename);  
        try{  
            if (f.createNewFile()){  
                ByteArrayOutputStream bos = new ByteArrayOutputStream();  
                bitmap.compress(Bitmap.CompressFormat.PNG, 0, bos);  
                byte[] bitmapdata = bos.toByteArray();  
                FileOutputStream fos = new FileOutputStream(f);  
                fos.write(bitmapdata);  
                fos.flush();  
                fos.close();  
            }  
        }catch (IOException e){  
            Log.e(TAG,"create bitmap file error" + e);  
        }  
        if (f.exists()){  
            return f.getAbsolutePath();  
        }  
        return null;  
    }  
  
    /** 
     * 将数据存储为文件 
     * 
     * @param data 数据 
     */  
    public static void createFile(byte[] data,String filename){  
        File f = new File(cacheDir, filename);  
        try{  
            if (f.createNewFile()){  
                FileOutputStream fos = new FileOutputStream(f);  
                fos.write(data);  
                fos.flush();  
                fos.close();  
            }  
        }catch (IOException e){  
            Log.e(TAG,"create file error" + e);  
        }  
    }  
  
  
    /** 
     * 将数据存储为文件 
     * 
     * @param data 数据 
     * @param fileName 文件名 
     * @param type 文件类型 
     */  
    public static boolean createFile(byte[] data, String fileName, String type){  
        if (isExternalStorageWritable()){  
            File dir = MyApp.applicationContext.getExternalFilesDir(type);
            if (dir != null){  
                File f = new File(dir, fileName);  
                try{  
                    if (f.createNewFile()){  
                        FileOutputStream fos = new FileOutputStream(f);  
                        fos.write(data);  
                        fos.flush();  
                        fos.close();  
                        return true;  
                    }  
                }catch (IOException e){  
                    Log.e(TAG,"create file error" + e);  
                    return false;  
                }  
            }  
        }  
        return false;  
    }  
  
  
    /** 
     * 从URI获取图片文件地址 
     * 
     * @param context 上下文 
     * @param uri 文件uri 
     */  
    public static String getImageFilePath(Context context, Uri uri) {  
        if (uri == null) {  
            return null;  
        }  
        String path = null;  
        final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;  
        if (isKitKat){  
            if (isMediaDocument(uri)){  
                try{  
                    final String docId = DocumentsContract.getDocumentId(uri);  
                    final String[] split = docId.split(":");  
                    Uri contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;  
                    final String selection = "_id=?";  
                    final String[] selectionArgs = new String[] {  
                            split[1]  
                    };  
                    path = getDataColumn(context, contentUri, selection, selectionArgs);  
                }catch (IllegalArgumentException e){  
                    path = null;  
                }  
            }  
        }  
        if (path == null){  
            String[] projection = {MediaStore.Images.Media.DATA};  
            Cursor cursor = ((Activity) context).managedQuery(uri, projection, null, null, null);  
            if (cursor != null) {  
                int column_index = cursor  
                        .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);  
                cursor.moveToFirst();  
                return cursor.getString(column_index);  
            }  
  
            path = null;  
        }  
        return path;  
    }  
  
  
    /** 
     * 从URI获取文件地址 
     * 
     * @param context 上下文 
     * @param uri 文件uri 
     */  
    public static String getFilePath(Context context, Uri uri) {  
        final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;  
        // DocumentProvider  
        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {  
            // ExternalStorageProvider  
            if (isExternalStorageDocument(uri)) {  
                final String docId = DocumentsContract.getDocumentId(uri);  
                final String[] split = docId.split(":");  
                final String type = split[0];  
  
                if ("primary".equalsIgnoreCase(type)) {  
                    return Environment.getExternalStorageDirectory() + "/" + split[1];  
                }  
  
                // TODO handle non-primary volumes  
            }  
            // DownloadsProvider  
            else if (isDownloadsDocument(uri)) {  
  
                final String id = DocumentsContract.getDocumentId(uri);  
                final Uri contentUri = ContentUris.withAppendedId(  
                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));  
  
                return getDataColumn(context, contentUri, null, null);  
            }  
            // MediaProvider  
            else if (isMediaDocument(uri)) {  
                final String docId = DocumentsContract.getDocumentId(uri);  
                final String[] split = docId.split(":");  
                final String type = split[0];  
  
                Uri contentUri = null;  
                if ("image".equals(type)) {  
                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;  
                } else if ("video".equals(type)) {  
                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;  
                } else if ("audio".equals(type)) {  
                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;  
                }  
  
                final String selection = "_id=?";  
                final String[] selectionArgs = new String[] {  
                        split[1]  
                };  
  
                return getDataColumn(context, contentUri, selection, selectionArgs);  
            }  
        }  
        // MediaStore (and general)  
        else if ("content".equalsIgnoreCase(uri.getScheme())) {  
            return getDataColumn(context, uri, null, null);  
        }  
        // File  
        else if ("file".equalsIgnoreCase(uri.getScheme())) {  
            return uri.getPath();  
        }  
  
        return null;  
    }  
  
  
  
  
  
  
    /** 
     * Get the value of the data column for this Uri. This is useful for 
     * MediaStore Uris, and other file-based ContentProviders. 
     * 
     * @param context The context. 
     * @param uri The Uri to query. 
     * @param selection (Optional) Filter used in the query. 
     * @param selectionArgs (Optional) Selection arguments used in the query. 
     * @return The value of the _data column, which is typically a file path. 
     */  
    private static String getDataColumn(Context context, Uri uri, String selection,  
                                        String[] selectionArgs) {  
        Cursor cursor = null;  
        final String column = "_data";  
        final String[] projection = {column};  
        try {  
            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);  
            if (cursor != null && cursor.moveToFirst()) {  
                final int index = cursor.getColumnIndexOrThrow(column);  
                return cursor.getString(index);  
            }  
        } finally {  
            if (cursor != null)  
                cursor.close();  
        }  
        return null;  
    }  
  
  
    /** 
     * 判断外部存储是否可用 
     * 
     */  
    public static boolean isExternalStorageWritable() {  
        String state = Environment.getExternalStorageState();  
        if (Environment.MEDIA_MOUNTED.equals(state)) {  
            return true;  
        }  
        Log.e(TAG, "ExternalStorage not mounted");  
        return false;  
    }  
  
    public static boolean isMediaDocument(Uri uri) {  
        return "com.android.providers.media.documents".equals(uri.getAuthority());  
    }  
  
    public static boolean isExternalStorageDocument(Uri uri) {  
        return "com.android.externalstorage.documents".equals(uri.getAuthority());  
    }  
  
    /** 
     * @param uri The Uri to check. 
     * @return Whether the Uri authority is DownloadsProvider. 
     */  
    public static boolean isDownloadsDocument(Uri uri) {  
        return "com.android.providers.downloads.documents".equals(uri.getAuthority());  
    }  
  
  
  
    public enum FileType{  
        IMG,  
        AUDIO,  
        VIDEO,  
        FILE,  
    }  
  
  
}  